home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / PRUS101.ZIP / FKBD.PAS < prev    next >
Pascal/Delphi Source File  |  1994-07-20  |  21KB  |  560 lines
  1. Unit FKBD; { FIDO Unit for keyboard handling and manipulation }
  2.  (***************************************************************************
  3.  
  4.             RELEASE 1.03 - as contained in the file PRUS100.LZH
  5.                 by Orazio Czerwenka, 2:2450/540.55, GERMANY
  6.  
  7.                --------------------------------------------
  8.                 organized for Fido's PASCAL related echoes    
  9.                --------------------------------------------
  10.  
  11.      05/22/1994 to --/--/---- by Orazio Czerwenka, 2:2450/540.55, GERMANY
  12.  
  13.  
  14.            As far as third party copyrights are not violated this
  15.            source code is hereby placed to the public domain. Use
  16.            it whatever way you want, but use AT YOUR OWN RISK.
  17.  
  18.            In case you should modify the source rather send your
  19.            modifications to the unit's current organizer (see above for
  20.            NM address) than to spread it on your own. This will help to
  21.            keep the unit updated and grant a certain standard to all
  22.            other users as well.
  23.  
  24.            The unit is currently still under work. So it might greatly
  25.            benefit of your participation.
  26.  
  27.            Those who contributed to the following piece of source,
  28.            listed in alphabethical order:
  29.         ================================================================
  30.            Martin Austermeier (Unit ReadKBD), Orazio Czerwenka, German
  31.            Borland HOST Langen (buffstuff.pas,flushkey.pas), Max
  32.            Maischein (Units CRT2.PAS and CHEAPCRT.PAS)...
  33.         ================================================================
  34.            YOUR NAME WILL APPEAR HERE IF YOU CONTRIBUTE USEFUL SOURCE.
  35.  
  36.            Special thanx to Max Maischein and Paul Schubert for pointing
  37.            out the advantages of word based keyboard related operations.
  38.  
  39.            Credits in your own programs are owed to Max Maischein as
  40.            demanded in his Units CRT2 and CHEAPCRT and to Borland in
  41.            general as well as to Martin Austermeier for his PD unit
  42.            ReadKBD.
  43.  
  44.  ***************************************************************************)
  45.  
  46. {$I FDEFINE.DEF}
  47.  
  48. interface
  49.  
  50. type
  51.   KbdBuff     = array[30..62] of byte;  { doesn't work as [0..32] ! why?  }
  52.  
  53. CONST
  54.   {        key codes         }
  55.   NUL        = $0000;  BKSPC      = $0E08;   TAB       = $0F09;
  56.   CR         = $1C0D;  ESC        = $011B;   SPC       = $3920;
  57.  
  58.   {   enhanced key codes   }
  59.   SHIFT_TAB  = $0F00;
  60.   CTRL_TAB = $9400;
  61.  
  62.   HOME       = $4700;  UP         = $4800;  PGUP       = $4900;
  63.   LEFT       = $4B00;  MIDDLE     = $4C35;  RIGHT      = $4D00;
  64.   ENDE       = $4F00;  DOWN       = $5000;  PGDN       = $5100;
  65.   INS        = $5200;  DEL        = $5300;
  66.  
  67.   GRAYPLUS   = $4E2B;  GRAYMINUS  = $4A2D;  GRAYDIV    = $E02F;
  68.   GRAYMUL    = $372A;  GRAYCR     = $E00D;
  69.  
  70.   F1         = $3B00;  F2         = $3C00;  F3         = $3D00;
  71.   F4         = $3E00;  F5         = $3F00;  F6         = $4000;
  72.   F7         = $4100;  F8         = $4200;  F9         = $4300;
  73.   F10        = $4400;  F11        = $8500;  F12        = $8600;
  74.  
  75.   SHIFT_F1   = $5400;  SHIFT_F2   = $5500;  SHIFT_F3   = $5600;
  76.   SHIFT_F4   = $5700;  SHIFT_F5   = $5800;  SHIFT_F6   = $5900;
  77.   SHIFT_F7   = $5A00;  SHIFT_F8   = $5B00;  SHIFT_F9   = $5C00;
  78.   SHIFT_F10  = $5D00;  SHIFT_F11  = $8700;  SHIFT_F12  = $8800;
  79.  
  80.   CTRL_F1    = $5E00;  CTRL_F2    = $5F00;  CTRL_F3    = $6000;
  81.   CTRL_F4    = $6100;  CTRL_F5    = $6200;  CTRL_F6    = $6300;
  82.   CTRL_F7    = $6400;  CTRL_F8    = $6500;  CTRL_F9    = $6600;
  83.   CTRL_F10   = $6700;  CTRL_F11   = $8900;  CTRL_F12   = $8A00;
  84.  
  85.   ALT_F1     = $6800;  ALT_F2     = $6900;  ALT_F3     = $6A00;
  86.   ALT_F4     = $6B00;  ALT_F5     = $6C00;  ALT_F6     = $6D00;
  87.   ALT_F7     = $6E00;  ALT_F8     = $6F00;  ALT_F9     = $7000;
  88.   ALT_F10    = $7100;  ALT_F11    = $8B00;  ALT_F12    = $8C00;
  89.  
  90.   CTRL_0     = $0B00;  CTRL_1     = $0200;  CTRL_2     = $0300;
  91.   CTRL_3     = $0400;  CTRL_4     = $0500;  CTRL_5     = $0600;
  92.   CTRL_6     = $071E;  CTRL_7     = $0800;  CTRL_8     = $0900;
  93.   CTRL_9     = $0A00;  CTRL_SZ    = $0C1F;  CTRL_APOST = $0D00;
  94.   CTRL_BKSPC = $0E7F;
  95.   CTRL_CR    = $1C0A;
  96.   CTRL_A     = $1E01;  CTRL_B     = $3002;  CTRL_C     = $2E03;
  97.   CTRL_D     = $2004;  CTRL_E     = $1205;  CTRL_F     = $2106;
  98.   CTRL_G     = $2207;  CTRL_H     = $2308;  CTRL_I     = $1709;
  99.   CTRL_J     = $240A;  CTRL_K     = $250B;  CTRL_L     = $260C;
  100.   CTRL_M     = $320D;  CTRL_N     = $310E;  CTRL_O     = $180F;
  101.   CTRL_P     = $1910;  CTRL_Q     = $1011;  CTRL_R     = $1312;
  102.   CTRL_S     = $1F13;  CTRL_T     = $1414;  CTRL_U     = $1615;
  103.   CTRL_V     = $2F16;  CTRL_W     = $1117;  CTRL_X     = $2D18;
  104.   CTRL_Y     = $1519;  CTRL_Z     = $2C1A;
  105.  
  106.   ALT_ESC    = $0100;
  107.   ALT_0      = $8100;  ALT_1      = $7800;  ALT_2      = $7900;
  108.   ALT_3      = $7A00;  ALT_4      = $7B00;  ALT_5      = $7C00;
  109.   ALT_6      = $7D00;  ALT_7      = $7E00;  ALT_8      = $7F00;
  110.   ALT_9      = $8000;  ALT_SZ     = $8200;  ALT_APOST  = $8300;
  111.   ALT_BKSPC  = $0E00;
  112.   ALT_CR     = $1C00;
  113.   ALT_A      = $1E00;  ALT_B      = $3000;  ALT_C      = $2E00;
  114.   ALT_D      = $2000;  ALT_E      = $1200;  ALT_F      = $2100;
  115.   ALT_G      = $2200;  ALT_H      = $2300;  ALT_I      = $1700;
  116.   ALT_J      = $2400;  ALT_K      = $2500;  ALT_L      = $2600;
  117.   ALT_M      = $3200;  ALT_N      = $3100;  ALT_O      = $1800;
  118.   ALT_P      = $1900;  ALT_Q      = $1000;  ALT_R      = $1300;
  119.   ALT_S      = $1F00;  ALT_T      = $1400;  ALT_U      = $1600;
  120.   ALT_V      = $2F00;  ALT_W      = $1100;  ALT_X      = $2D00;
  121.   ALT_Y      = $1500;  ALT_Z      = $2C00;
  122.  
  123.   ALT_SPC    = $3900;
  124.  
  125.   CTRL_UP    = $8D00;  CTRL_DOWN  = $9100;  CTRL_LEFT  = $7300;
  126.   CTRL_RIGHT = $7400;  CTRL_HOME  = $7700;  CTRL_END   = $7500;
  127.   CTRL_DEL   = $9300;  CTRL_INS   = $9200;
  128.  
  129.   IDE_INS      = $0500; IDE_DEL      = $0700;
  130.   IDE_CTRL_INS = $0400; IDE_CTRL_DEL = $0600;
  131.   IDE_ALT_SPC  = $0200;
  132.  
  133.   ALT_UP     = $9800;  ALT_DOWN   = $A000;  ALT_LEFT   = $9B00;
  134.   ALT_RIGHT  = $9D00;
  135.  
  136.  
  137. var
  138.   KBDHead     : integer absolute $0000:$041A;
  139.   KBDTail     : integer absolute $0000:$041C;
  140.   KBDSeg      : KbdBuff absolute $0000:$041E;
  141.  
  142. function ScrlPressed : Boolean; function ScrlActive  : Boolean;
  143. function NumPressed  : Boolean; function NumActive   : Boolean;
  144. function CapsPressed : Boolean; function CapsActive  : Boolean;
  145. function InsPressed  : Boolean; function InsActive   : Boolean;
  146.  
  147. function ShiftPressed: Boolean;
  148. function LeftShiftPressed: Boolean;
  149. function RightShiftPressed: Boolean;
  150.  
  151. function CtrlPressed : Boolean;
  152. { Original author: Max Maischein }
  153. Inline(
  154. $31/$F6/            {XOR    SI,SI        }
  155. $8E/$C6/            {MOV    ES,SI        }
  156. $26/                {ES:                 }
  157. $A0/$17/$04/        {MOV    AL,[0417]    }
  158. $A8/$04/            {TEST   AL,04        }
  159. $B0/$01/            {MOV    AL,01        }
  160. $75/$02/            {JNZ    $+2          }
  161. $FE/$C8             {DEC    AL           }
  162. );
  163.  
  164. function LeftCTRLPressed: Boolean;
  165. function RightCTRLPressed: Boolean;
  166.  
  167. function ALTPressed : Boolean;
  168. { Original author: Max Maischein }
  169. Inline(
  170. $31/$F6/            {XOR    SI,SI        }
  171. $8E/$C6/            {MOV    ES,SI        }
  172. $26/                {ES:                 }
  173. $A0/$17/$04/        {MOV    AL,[0417]    }
  174. $A8/$08/            {TEST   AL,08        }
  175. $B0/$01/            {MOV    AL,01        }
  176. $75/$02/            {JNZ    $+2          }
  177. $FE/$C8             {DEC    AL           }
  178. );
  179.  
  180. function LeftALTPressed: Boolean;
  181. function RightALTPressed: Boolean;
  182.  
  183. function  EnhancedKBDPresent : Boolean;
  184. function  ExtendedKeysAllowed: Boolean;
  185. procedure EnableExtendedKeys;
  186. procedure DisableExtendedKeys;
  187.  
  188. function  KeyPressed : Boolean;
  189. function  ReadKey : Char;
  190. function  PeekKey : Char;
  191. function  ReadKeyWord : Word;
  192. function  PeekKeyWord : Word;
  193.  
  194. function  NormalKey : char; { like readkey, but excepts only normal keys }
  195.  
  196. procedure ClrKbd;                           { clear the keyboard buffer  }
  197. procedure Char2KBD (ch:char;code:byte);     { put Char end extended code }
  198. procedure Word2Kbd(w: Word);                { put Word to buffer         }
  199.  
  200. implementation
  201.  
  202. const
  203.   NormalKeyExceptions = [#13,#27]; { Insert all chars < 32 to be excepted by
  204.                                      NormalKey here }
  205.  
  206. var
  207.   KBDFlag0   : Byte Absolute $40:$17;
  208.   KBDFlag1   : Byte Absolute $40:$18;
  209.   KBDFlag2   : Byte Absolute $40:$97;
  210.   KBDFlag3   : Byte Absolute $40:$96;
  211.  
  212.   keyCmd,                  { "base command" for int 16h }
  213.   extKey      : Byte;      { buffer for extended keys   }
  214.  
  215. function ScrlPressed : Boolean;
  216. { Original author: Max Maischein }
  217. begin ScrlPressed := (KBDFlag1 AND 16) <> 0; end;
  218.  
  219. function ScrlActive  : Boolean;
  220. { Original author: Max Maischein }
  221. begin ScrlActive := (KBDFlag0 AND 16) <> 0; end;
  222.  
  223. function NumPressed : Boolean;
  224. { Original author: Max Maischein }
  225. begin NumPressed := (KBDFlag1 AND 32) <> 0; end;
  226.  
  227. function NumActive   : Boolean;
  228. { Original author: Max Maischein }
  229. begin NumActive := (KBDFlag0 AND 32) <> 0; end;
  230.  
  231. function CapsPressed : Boolean;
  232. { Original author: Max Maischein }
  233. begin CapsPressed := (KBDFlag1 AND 64) <> 0; end;
  234.  
  235. function CapsActive  : Boolean;
  236. { Original author: Max Maischein }
  237. begin CapsActive := (KBDFlag0 AND 64) <> 0; end;
  238.  
  239. function InsActive   : Boolean;
  240. { Original author: Max Maischein }
  241. begin InsActive := (KBDFlag0 AND 128) <> 0; end;
  242.  
  243. function InsPressed : Boolean;
  244. { Original author: Max Maischein }
  245. begin InsPressed := (KBDFlag1 AND 128) <> 0; end;
  246.  
  247. function LeftShiftPressed: Boolean;
  248. { Original author: Orazio Czerwenka }
  249. begin LeftShiftPressed:= (KBDFlag0 AND 2) <> 0; end;
  250.  
  251. function RightShiftPressed: Boolean;
  252. { Original author: Orazio Czerwenka }
  253. begin RightShiftPressed:= (KBDFlag0 AND 1) <> 0; end;
  254.  
  255. function ShiftPressed: Boolean;
  256. { Original author: Orazio Czerwenka }
  257. begin ShiftPressed:= RightShiftPressed OR LeftShiftPressed; end;
  258.  
  259. function LeftCTRLPressed: Boolean;
  260. { Original author: Orazio Czerwenka }
  261. begin LeftCTRLPressed:= (KBDFlag1 AND 1) <> 0; end;
  262.  
  263. function RightCTRLPressed: Boolean;
  264. { Original author: Orazio Czerwenka }
  265. begin RightCTRLPressed:= (KBDFlag3 AND 4) <> 0; end;
  266.  
  267. function LeftALTPressed: Boolean;
  268. { Original author: Orazio Czerwenka }
  269. begin LeftALTPressed:= (KBDFlag1 AND 2) <> 0; end;
  270.  
  271. function RightALTPressed: Boolean;
  272. { Original author: Orazio Czerwenka }
  273. begin RightALTPressed:= (KBDFlag3 AND 8) <> 0; end;
  274.  
  275. { ************************************************************************** }
  276. { ╒═════════════════════════════════════════════════════════════════════════╕}
  277. { │ EnhancedKBDPresent : Boolean                                            │}
  278. { ╘═════════════════════════════════════════════════════════════════════════╛}
  279. function EnhancedKBDPresent : boolean; 
  280. { Original author: Max Maischein, Unit CRT2;
  281.   modificatons by Orazio Czerwenka according to
  282.   Martin Austermeier's Unit ReadKBD }
  283. begin
  284.   asm
  285.     sub al, al
  286.     mov [extKey], al    { init ReadKey }
  287.     mov [keyCmd], al    { normal Cmd (0) }
  288.     mov al, 0FFh
  289.     mov ah, 12h         { get shift states :}
  290.     int 16h
  291.     cmp al, 0FFh        { shifts? }
  292.     je  @@NoEnhKbd      { not supported -> }
  293.     mov @result, 0h     { TRUE }
  294.   @@NoEnhKbd:
  295.     mov @result, 1h     { FALSE }
  296.   end;
  297. end;
  298.  
  299. { ************************************************************************** }
  300. { ╒═════════════════════════════════════════════════════════════════════════╕}
  301. { │ ExtendedKeysAllowed: Boolean                                            │}
  302. { ╘═════════════════════════════════════════════════════════════════════════╛}
  303. function ExtendedKeysAllowed: Boolean;
  304. { Original author: Orazio Czerwenka }
  305. begin
  306.   ExtendedKeysAllowed:= (keyCmd = $10);
  307. end;
  308.  
  309. { ************************************************************************** }
  310. { ╒═════════════════════════════════════════════════════════════════════════╕}
  311. { │ EnableExtendedKeys                                                      │}
  312. { ╘═════════════════════════════════════════════════════════════════════════╛}
  313. procedure EnableExtendedKeys; 
  314. { Original author: Orazio Czerwenka }
  315. begin
  316.   if EnhancedKBDPresent then
  317.   asm
  318.     mov [keyCmd], 10h   { enhanced keyboard support }
  319.   end;
  320. end;
  321.  
  322. { ************************************************************************** }
  323. { ╒═════════════════════════════════════════════════════════════════════════╕}
  324. { │ DisableExtendedKeys                                                     │}
  325. { ╘═════════════════════════════════════════════════════════════════════════╛}
  326. procedure DisableExtendedKeys; assembler;
  327. { Original author: Orazio Czerwenka }
  328. ASM
  329.   mov [keyCmd], 0h   { disable enhanced keyboard support }
  330. END;
  331.  
  332. { ************************************************************************** }
  333. { ╒═════════════════════════════════════════════════════════════════════════╕}
  334. { │ KeyPressed : Boolean                                                    │}
  335. { ╘═════════════════════════════════════════════════════════════════════════╛}
  336. function KeyPressed : Boolean; assembler;
  337. { Original author: Martin Austermeier }
  338. ASM
  339.   cmp [extKey], 0      { extended key pending? }
  340.   jne @@True           { yes -> }
  341.   mov ah, [keyCmd]     { 0/10 }
  342.   inc ah               { keypressed function (01/11) }
  343.   int 16h
  344.   mov al, FALSE        { key available? }
  345.   jz  @@Exit           { no -> }
  346. @@True:
  347.   mov al, TRUE
  348. @@Exit:
  349. END;  { KeyPressed }
  350.  
  351. { ************************************************************************** }
  352. {╒═════════════════════════════════════════════════════════════════════════╕ }
  353. {│ ReadKey : Char;                                                         │ }
  354. {╘═════════════════════════════════════════════════════════════════════════╛ }
  355. function ReadKey : Char; assembler;
  356. { Original author: Martin Austermeier }
  357. ASM
  358.   mov al, [extKey]     { get saved ext.key }
  359.   mov [extKey], 0      { reset }
  360.   or al, al            { previous = extended key? }
  361.   jne @@End            { nope -> }
  362.   mov ah, [keyCmd]     { read key }
  363.   int 16h
  364.   cmp al, 0E0h         { extended keyboard, cursor keys }
  365.   jne @@NoE0           { no cursor key -> }
  366.   or ah, ah            { "α" (E0) allowed }
  367.   jnz @@Ext
  368. @@NoE0:
  369.   or al, al            { LowByte=0? }
  370.   jnz @@End            { no, valid key -> }
  371. @@Ext:
  372.   sub al, al           { return 0 }
  373.   mov [extKey], AH     { save extended key }
  374. @@End:
  375.   xor ah, ah           { return AL only }
  376. END;  { ReadKey }
  377.  
  378. { ************************************************************************** }
  379. {╒═════════════════════════════════════════════════════════════════════════╕ }
  380. {│ PeekKey : Char;                                                         │ }
  381. {╘═════════════════════════════════════════════════════════════════════════╛ }
  382. function PeekKey : Char; assembler;
  383. { Original author: Martin Austermeier,
  384.   modifications made by Orazio Czerwenka
  385.   based upon ReadKey }
  386. ASM
  387.   mov al, [extKey]     { get saved ext.key }
  388.   mov [extKey], 0      { reset }
  389.   or al, al            { previous = extended key? }
  390.   jne @@End            { nope -> }
  391.   mov ah, [keyCmd]     { read key }
  392.   inc ah               { peek key instead }
  393.   int 16h
  394.   cmp al, 0E0h         { extended keyboard, cursor keys }
  395.   jne @@NoE0           { no cursor key -> }
  396.   or ah, ah            { "α" (E0) allowed }
  397.   jnz @@Ext
  398. @@NoE0:
  399.   or al, al            { LowByte=0? }
  400.   jnz @@End            { no, valid key -> }
  401. @@Ext:
  402.   sub al, al           { return 0 }
  403.   mov [extKey], AH     { save extended key }
  404. @@End:
  405.   xor ah, ah           { return AL only }
  406. END;  { ReadKey }
  407.  
  408.  
  409. { ************************************************************************** }
  410. {╒═════════════════════════════════════════════════════════════════════════╕ }
  411. {│ ReadKeyWord : Word;                                                     │ }
  412. {╘═════════════════════════════════════════════════════════════════════════╛ }
  413. function ReadKeyWord : Word; assembler;
  414. { Original author: Martin Austermeier
  415.   modifications based upon ReadKey by
  416.   Orazio Czerwenka }
  417. ASM
  418.   (*
  419.   mov al, [extKey]     { get saved ext.key }
  420.   mov [extKey], 0      { reset }
  421.   or al, al            { previous = extended key? }
  422.   jne @@End            { nope -> }
  423.   *)
  424.   mov ah, [keyCmd]     { read key }
  425.   int 16h
  426.   cmp al, 0E0h         { extended keyboard, cursor keys }
  427.   jne @@NoE0           { no cursor key -> }
  428.   or ah, ah            { "α" (E0) allowed }
  429.   jnz @@Ext
  430. @@NoE0:
  431.   or al, al            { LowByte=0? }
  432.   jnz @@End            { no, valid key -> }
  433. @@Ext:
  434.   sub al, al           { return 0 }
  435.   mov [extKey], AH     { save extended key }
  436. @@End:
  437. (*  xor ah, ah           { return AL only }*)
  438. END;  { ReadKey }
  439.  
  440. { ************************************************************************** }
  441. {╒═════════════════════════════════════════════════════════════════════════╕ }
  442. {│ PeekKeyWord : Word;                                                     │ }
  443. {╘═════════════════════════════════════════════════════════════════════════╛ }
  444. function PeekKeyWord : Word; assembler;
  445. { Original author: Martin Austermeier
  446.   modifications based upon ReadKey by
  447.   Orazio Czerwenka }
  448. ASM
  449.   (*
  450.   mov al, [extKey]     { get saved ext.key }
  451.   mov [extKey], 0      { reset }
  452.   or al, al            { previous = extended key? }
  453.   jne @@End            { nope -> }
  454.   *)
  455.   mov ah, [keyCmd]     { read key }
  456.   inc ah               { peek key instead }
  457.   int 16h
  458.   cmp al, 0E0h         { extended keyboard, cursor keys }
  459.   jne @@NoE0           { no cursor key -> }
  460.   or ah, ah            { "α" (E0) allowed }
  461.   jnz @@Ext
  462. @@NoE0:
  463.   or al, al            { LowByte=0? }
  464.   jnz @@End            { no, valid key -> }
  465. @@Ext:
  466.   sub al, al           { return 0 }
  467.   mov [extKey], AH     { save extended key }
  468. @@End:
  469. (*  xor ah, ah           { return AL only }*)
  470. END;  { ReadKey }
  471.  
  472.  
  473. { ************************************************************************** }
  474.  
  475. function NormalKey : char;
  476. { Original author: Max Maischein, Unit CRT2;
  477.   modifications by Orazio Czerwenka }
  478. var
  479.   ch : word;
  480.   b  : boolean;
  481. begin
  482.   b:= false;
  483.   Repeat
  484.   ch := word(readKey);
  485.   If (lo(ch) <> 0) and ((lo(ch) > 31) or (chr(ch) in NormalKeyExceptions))
  486.     then b:= true
  487.     else ch:= word(readkey);
  488.   Until b;
  489.   if not (chr(ch) in NormalKeyExceptions)
  490.     then NormalKey:= chr(lo(ch))
  491.     else NormalKey:= #13;
  492. end;
  493.  
  494. { ************************************************************************** }
  495.  
  496. procedure ClrKbd; assembler;              { adapted of FLUSHKEY.PAS from    }
  497. { Modifications: Orazio Czerwenka }       { Borland-Net host, Langen        }
  498. asm
  499.   mov  ax, 0Ch
  500.   shl  ax, 8
  501.   or   ax, ax
  502.   mov  dx, 00FFh
  503.   int  21h
  504. end;
  505.  
  506. { ************************************************************************** }
  507.  
  508. procedure Char2Kbd(ch:char;code:byte);    { adapted of BUFSTUFF.PAS from    }
  509. { Modifications: Orazio Czerwenka }       { Borland-Net host, Langen        }
  510. var                                       
  511.   TmpTail : integer;
  512. begin
  513.    TmpTail:= KBDTail;                       { store the current end of buffer }
  514.    KBDTail:= KBDTail + 2;                   { incriment to next position      }
  515.    if KBDHead = KBDTail then                { if the buffer is full (?) ...   }
  516.    begin
  517.       KBDTail:= TmpTail;                    { ... restore the previous value  }
  518.    end
  519.    else
  520.    begin
  521.      KbdSeg[TmpTail]:= ord(ch);            { put ASCII value in buffer       }
  522.      KbdSeg[TmpTail+1]:= code;             { put extended key code           }
  523.      if KBDTail > 60                       { reached buffer's end ? ...      }
  524.        then KBDTail:= 30;                  { ... wrap to first position !    }
  525.    end;
  526. end;
  527.  
  528. { ************************************************************************** }
  529.  
  530. procedure Word2Kbd(w: Word);              { adapted of BUFSTUFF.PAS from    }
  531. { Modifications: Orazio Czerwenka }       { Borland-Net host, Langen        }
  532. var                                       
  533.   TmpTail : integer;
  534. begin
  535.    TmpTail:= KBDTail;                       { store the current end of buffer }
  536.    KBDTail:= KBDTail + 2;                   { incriment to next position      }
  537.    if KBDHead = KBDTail then                { if the buffer is full (?) ...   }
  538.    begin
  539.       KBDTail:= TmpTail;                    { ... restore the previous value  }
  540.    end
  541.    else
  542.    begin
  543.      KbdSeg[TmpTail]:= Lo(w);               { put ASCII value in buffer       }
  544.      KbdSeg[TmpTail+1]:= Hi(w);             { put extended key code           }
  545.      if KBDTail > 60                        { reached buffer's end ? ...      }
  546.        then KBDTail:= 30;                   { ... wrap to first position !    }
  547.    end;
  548. end;
  549.  
  550. { ************************************************************************** }
  551. procedure InitFKBD;
  552. begin
  553.   DisableExtendedKeys;   { ensure TP compatibility by default }
  554. end;
  555.  
  556. {$IFOPT O-}
  557. begin
  558.   InitFKBD;
  559. {$ENDIF}
  560. end.